/**
 * 此脚本用于直接更新MongoDB中抽象工厂模式的示例代码
 */
const { MongoClient } = require('mongodb');
require('dotenv').config();

// MongoDB连接配置
const MONGODB_URI = process.env.MONGODB_URI || 'mongodb://gof23user:gof23password@localhost:27017/gof23-game';

// 抽象工厂模式Java示例代码
const abstractFactoryCode = `/**
 * 抽象工厂模式示例
 */
// 抽象产品A
interface AbstractProductA {
    void operationA();
}

// 抽象产品B
interface AbstractProductB {
    void operationB();
    // 与产品A协作的方法
    void collaborateWithA(AbstractProductA productA);
}

// 具体产品A1
class ConcreteProductA1 implements AbstractProductA {
    @Override
    public void operationA() {
        System.out.println("Product A1 operation");
    }
}

// 具体产品A2
class ConcreteProductA2 implements AbstractProductA {
    @Override
    public void operationA() {
        System.out.println("Product A2 operation");
    }
}

// 具体产品B1
class ConcreteProductB1 implements AbstractProductB {
    @Override
    public void operationB() {
        System.out.println("Product B1 operation");
    }
    
    @Override
    public void collaborateWithA(AbstractProductA productA) {
        System.out.println("Product B1 collaborating with " + productA.getClass().getSimpleName());
    }
}

// 具体产品B2
class ConcreteProductB2 implements AbstractProductB {
    @Override
    public void operationB() {
        System.out.println("Product B2 operation");
    }
    
    @Override
    public void collaborateWithA(AbstractProductA productA) {
        System.out.println("Product B2 collaborating with " + productA.getClass().getSimpleName());
    }
}

// 抽象工厂
interface AbstractFactory {
    AbstractProductA createProductA();
    AbstractProductB createProductB();
}

// 具体工厂1 - 创建产品A1和B1
class ConcreteFactory1 implements AbstractFactory {
    @Override
    public AbstractProductA createProductA() {
        return new ConcreteProductA1();
    }
    
    @Override
    public AbstractProductB createProductB() {
        return new ConcreteProductB1();
    }
}

// 具体工厂2 - 创建产品A2和B2
class ConcreteFactory2 implements AbstractFactory {
    @Override
    public AbstractProductA createProductA() {
        return new ConcreteProductA2();
    }
    
    @Override
    public AbstractProductB createProductB() {
        return new ConcreteProductB2();
    }
}

// 客户端代码
public class Client {
    public static void main(String[] args) {
        // 使用工厂1
        AbstractFactory factory1 = new ConcreteFactory1();
        AbstractProductA productA1 = factory1.createProductA();
        AbstractProductB productB1 = factory1.createProductB();
        
        productA1.operationA();
        productB1.operationB();
        productB1.collaborateWithA(productA1);
        
        // 使用工厂2
        AbstractFactory factory2 = new ConcreteFactory2();
        AbstractProductA productA2 = factory2.createProductA();
        AbstractProductB productB2 = factory2.createProductB();
        
        productA2.operationA();
        productB2.operationB();
        productB2.collaborateWithA(productA2);
    }
}`;

async function updateAbstractFactoryCode() {
  let client;

  try {
    // 连接数据库
    client = new MongoClient(MONGODB_URI);
    await client.connect();
    console.log('MongoDB 连接成功');
    
    const db = client.db(); // 使用默认数据库
    const patternsCollection = db.collection('patterns');
    
    // 查找抽象工厂模式
    const pattern = await patternsCollection.findOne({ name: 'Abstract Factory' });
    
    if (!pattern) {
      console.log('未找到抽象工厂模式');
      process.exit(1);
    }
    
    // 更新示例代码
    await patternsCollection.updateOne(
      { name: 'Abstract Factory' },
      { $set: { sampleCode: abstractFactoryCode } }
    );
    
    console.log('成功更新抽象工厂模式示例代码');
  } catch (err) {
    console.error('更新抽象工厂模式示例代码失败:', err);
    process.exit(1);
  } finally {
    // 关闭连接
    if (client) {
      await client.close();
    }
    process.exit(0);
  }
}

// 执行更新
updateAbstractFactoryCode(); 